home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / GCC-2.3.3r12 / Sources / loop.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-02-05  |  7.3 KB  |  176 lines  |  [TEXT/MPS ]
  1. /* Loop optimization definitions for GNU C-Compiler
  2.    Copyright (C) 1991 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* Get the luid of an insn.  Catch the error of trying to reference the LUID
  21.    of an insn added during loop, since these don't have LUIDs.  */
  22.  
  23. #define INSN_LUID(INSN)            \
  24.   (INSN_UID (INSN) < max_uid_for_loop ? uid_luid[INSN_UID (INSN)] \
  25.    : (abort (), -1))
  26.  
  27. /* A "basic induction variable" or biv is a pseudo reg that is set
  28.    (within this loop) only by incrementing or decrementing it.  */
  29. /* A "general induction variable" or giv is a pseudo reg whose
  30.    value is a linear function of a biv.  */
  31.  
  32. /* Bivs are recognized by `basic_induction_var';
  33.    Givs by `general_induct_var'.  */
  34.  
  35. /* An enum for the two different types of givs, those that are used
  36.    as memory addresses and those that are calculated into registers.  */
  37. #ifdef MPW_C
  38. enum g_types { DEST_ADDR, DEST_REG, GTY_intifier = 1000000 };
  39. #else
  40. enum g_types { DEST_ADDR, DEST_REG };
  41. #endif
  42. /* A `struct induction' is created for every instruction that sets
  43.    an induction variable (either a biv or a giv).  */
  44.  
  45. struct induction
  46. {
  47.   rtx insn;            /* The insn that sets a biv or giv */
  48.   rtx new_reg;            /* New register, containing strength reduced
  49.                    version of this giv.  */
  50.   rtx src_reg;            /* Biv from which this giv is computed.
  51.                    (If this is a biv, then this is the biv.) */
  52.   enum g_types giv_type;    /* Indicate whether DEST_ADDR or DEST_REG */
  53.   rtx dest_reg;            /* Destination register for insn: this is the
  54.                    register which was the biv or giv.
  55.                    For a biv, this equals src_reg.
  56.                    For a DEST_ADDR type giv, this is 0.  */
  57.   rtx *location;        /* Place in the insn where this giv occurs.
  58.                    If GIV_TYPE is DEST_REG, this is 0.  */
  59.   enum machine_mode mode;    /* The mode of this biv or giv */
  60.   enum machine_mode mem_mode;    /* For DEST_ADDR, mode of the memory object. */
  61.   rtx mult_val;            /* Multiplicative factor for src_reg.  */
  62.   rtx add_val;            /* Additive constant for that product.  */
  63.   int benefit;            /* Gain from eliminating this insn.  */
  64.   rtx final_value;        /* If the giv is used outside the loop, and its
  65.                    final value could be calculated, it is put
  66.                    here, and the giv is made replaceable.  Set
  67.                    the giv to this value before the loop.  */
  68.   unsigned replaceable : 1;    /* 1 if we can substitute the strength-reduced
  69.                    variable for the original variable.
  70.                    0 means they must be kept separate and the
  71.                    new one must be copied into the old pseudo
  72.                    reg each time the old one is set.  */
  73.   unsigned not_replaceable : 1;    /* Used to prevent duplicating work.  This is
  74.                    1 if we know that the giv definitely can
  75.                    not be made replaceable, in which case we
  76.                    don't bother checking the variable again
  77.                    even if further info is available.
  78.                    Both this and the above can be zero.  */
  79.   unsigned ignore : 1;        /* 1 prohibits further processing of giv */
  80.   unsigned always_computable : 1;/* 1 if this set occurs each iteration */
  81.   unsigned maybe_multiple : 1;    /* Only used for a biv and  1 if this biv
  82.                    update may be done multiple times per
  83.                    iteration. */
  84.   unsigned cant_derive : 1;    /* For giv's, 1 if this giv cannot derive
  85.                    another giv.  This occurs in many cases
  86.                    where a giv's lifetime spans an update to
  87.                    a biv. */
  88.   unsigned combined_with : 1;    /* 1 if this giv has been combined with.  It
  89.                    then cannot combine with any other giv.  */
  90.   unsigned maybe_dead : 1;    /* 1 if this giv might be dead.  In that case,
  91.                    we won't use it to eliminate a biv, it
  92.                    would probably lose. */
  93.   int lifetime;            /* Length of life of this giv */
  94.   int times_used;        /* # times this giv is used. */
  95.   rtx derive_adjustment;    /* If nonzero, is an adjustment to be
  96.                    subtracted from add_val when this giv
  97.                    derives another.  This occurs when the
  98.                    giv spans a biv update by incrementation. */
  99.   struct induction *next_iv;    /* For givs, links together all givs that are
  100.                    based on the same biv.  For bivs, links
  101.                    together all biv entries that refer to the
  102.                    same biv register.  */
  103.   struct induction *same;    /* If this giv has been combined with another
  104.                    giv, this points to the base giv.  The base
  105.                    giv will have COMBINED_WITH non-zero.  */
  106.   HOST_WIDE_INT const_adjust;    /* Used by loop unrolling, when an address giv
  107.                    is split, and a constant is eliminated from
  108.                    the address, the -constant is stored here
  109.                    for later use. */
  110. };
  111.  
  112. /* A `struct iv_class' is created for each biv.  */
  113.  
  114. struct iv_class {
  115.   int regno;            /* Pseudo reg which is the biv.  */
  116.   int biv_count;        /* Number of insns setting this reg.  */
  117.   struct induction *biv;    /* List of all insns that set this reg.  */
  118.   int giv_count;        /* Number of DEST_REG givs computed from this
  119.                    biv.  The resulting count is only used in
  120.                    check_dbra_loop.  */
  121.   struct induction *giv;    /* List of all insns that compute a giv
  122.                    from this reg.  */
  123.   int total_benefit;        /* Sum of BENEFITs of all those givs */
  124.   rtx initial_value;        /* Value of reg at loop start */
  125.   rtx initial_test;        /* Test performed on BIV before loop */
  126.   struct iv_class *next;    /* Links all class structures together */
  127.   rtx init_insn;        /* insn which initializes biv, 0 if none. */
  128.   rtx init_set;            /* SET of INIT_INSN, if any. */
  129.   unsigned incremented : 1;    /* 1 if somewhere incremented/decremented */
  130.   unsigned eliminable : 1;    /* 1 if plausible candidate for elimination. */
  131.   unsigned nonneg : 1;        /* 1 if we added a REG_NONNEG note for this. */
  132.   unsigned reversed : 1;    /* 1 if we reversed the loop that this
  133.                    biv controls. */
  134. };
  135.  
  136. /* Definitions used by the basic induction variable discovery code.  */
  137. enum iv_mode { UNKNOWN_INDUCT, BASIC_INDUCT, NOT_BASIC_INDUCT,
  138. #ifdef MPW_C
  139.          GENERAL_INDUCT, IVM_initifer = 1000000 };
  140. #else
  141.          GENERAL_INDUCT };
  142. #endif
  143. /* Variables declared in loop.c, but also needed in unroll.c.  */
  144.  
  145. extern int *uid_luid;
  146. extern int max_uid_for_loop;
  147. extern int *uid_loop_num;
  148. extern int *loop_outer_loop;
  149. extern rtx *loop_number_exit_labels;
  150. extern unsigned HOST_WIDE_INT loop_n_iterations;
  151. extern int max_reg_before_loop;
  152.  
  153. extern FILE *loop_dump_stream;
  154.  
  155. extern enum iv_mode *reg_iv_type;
  156. extern struct induction **reg_iv_info;
  157. extern struct iv_class **reg_biv_class;
  158. extern struct iv_class *loop_iv_list;
  159.  
  160. /* Forward declarations for non-static functions declared in loop.c and
  161.    unroll.c.  */
  162. int invariant_p ();
  163. rtx get_condition_for_loop ();
  164. void emit_iv_add_mult ();
  165.  
  166. /* Forward declarations for non-static functions declared in stmt.c.  */
  167. void find_loop_tree_blocks ();
  168. void unroll_block_trees ();
  169.  
  170. void unroll_loop ();
  171. rtx biv_total_increment ();
  172. unsigned HOST_WIDE_INT loop_iterations ();
  173. rtx final_biv_value ();
  174. rtx final_giv_value ();
  175. void emit_unrolled_add ();
  176.